{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "dc701564",
   "metadata": {},
   "source": [
    "# Tabular regressions\n",
    "In this notebook we do regression and obtain conformal intervals of predictions for several tabular data sets."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc723afd",
   "metadata": {},
   "source": [
    "### Download regression datasets from UCI\n",
    "We create the infrastructure to download several regression data sets from [UCI](https://archive.ics.uci.edu/ml/datasets.php). Feel free to run this cell without looking into it, as it does not offer insights about Fortuna."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e793b926",
   "metadata": {},
   "outputs": [],
   "source": [
    "import abc\n",
    "import logging\n",
    "import os\n",
    "import zipfile\n",
    "from typing import Tuple\n",
    "from urllib.request import urlopen\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from fortuna.data import DataLoader\n",
    "\n",
    "_ALL_REGRESSION_DATASETS = {}\n",
    "\n",
    "\n",
    "def add_regression(C):\n",
    "    _ALL_REGRESSION_DATASETS.update({C.name: C})\n",
    "    return C\n",
    "\n",
    "\n",
    "class Dataset:\n",
    "    def __init__(self, name: str, url: str, directory: str):\n",
    "        self.name = name\n",
    "        self.url = url\n",
    "        self.directory = directory\n",
    "\n",
    "    @property\n",
    "    def datadir(self):\n",
    "        return os.path.join(self.directory, self.name)\n",
    "\n",
    "    @property\n",
    "    def datapath(self):\n",
    "        return os.path.join(self.datadir, self.url.split(\"/\")[-1])\n",
    "\n",
    "    @abc.abstractmethod\n",
    "    def read(self) -> Tuple[np.ndarray, np.ndarray]:\n",
    "        pass\n",
    "\n",
    "    def shuffle(self, X: np.array, Y: np.array, seed: int = 0):\n",
    "        N = X.shape[0]\n",
    "        perm = np.arange(N)\n",
    "        np.random.seed(seed)\n",
    "        np.random.shuffle(perm)\n",
    "        return X[perm], Y[perm]\n",
    "\n",
    "    def normalize(self, Z: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:\n",
    "        Z_mean = np.mean(Z, 0, keepdims=True)\n",
    "        Z_std = 1e-6 + np.std(Z, 0, keepdims=True)\n",
    "        return (Z - Z_mean) / Z_std, Z_mean, Z_std\n",
    "\n",
    "    def preprocess(self, X: np.ndarray, Y: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:\n",
    "        X, self.X_mean, self.X_std = self.normalize(X)\n",
    "        Y, self.Y_mean, self.Y_std = self.normalize(Y)\n",
    "        return X, Y\n",
    "\n",
    "    def split(\n",
    "        self,\n",
    "        X: np.array,\n",
    "        Y: np.array,\n",
    "        prop_train: float = 0.8,\n",
    "        prop_val: float = 0.1,\n",
    "    ) -> Tuple[\n",
    "        Tuple[np.ndarray, np.ndarray],\n",
    "        Tuple[np.ndarray, np.ndarray],\n",
    "        Tuple[np.ndarray, np.ndarray],\n",
    "    ]:\n",
    "        N = X.shape[0]\n",
    "        n_train = int(N * prop_train)\n",
    "        n_val = int(N * prop_val)\n",
    "        train_data = X[:n_train], Y[:n_train]\n",
    "        val_data = X[n_train : n_train + n_val], Y[n_train : n_train + n_val]\n",
    "        test_data = X[n_train + n_val :], Y[n_train + n_val :]\n",
    "        return train_data, val_data, test_data\n",
    "\n",
    "    def batch(\n",
    "        self,\n",
    "        train_data: Tuple[np.ndarray, np.ndarray],\n",
    "        val_data: Tuple[np.ndarray, np.ndarray],\n",
    "        test_data: Tuple[np.ndarray, np.ndarray],\n",
    "        batch_size: int = 128,\n",
    "        shuffle_train: bool = False,\n",
    "        prefetch: bool = True,\n",
    "    ) -> Tuple[DataLoader, DataLoader, DataLoader]:\n",
    "        train_data_loader = DataLoader.from_array_data(\n",
    "            train_data, batch_size=batch_size, shuffle=shuffle_train, prefetch=prefetch\n",
    "        )\n",
    "        val_data_loader = DataLoader.from_array_data(\n",
    "            val_data, batch_size=batch_size, prefetch=prefetch\n",
    "        )\n",
    "        test_data_loader = DataLoader.from_array_data(\n",
    "            test_data, batch_size=batch_size, prefetch=prefetch\n",
    "        )\n",
    "        return train_data_loader, val_data_loader, test_data_loader\n",
    "\n",
    "    def load(\n",
    "        self,\n",
    "        prop_train: float = 0.8,\n",
    "        prop_val: float = 0.1,\n",
    "        batch_size: int = 128,\n",
    "        shuffle_train: bool = False,\n",
    "        prefetch: bool = True,\n",
    "    ) -> Tuple[DataLoader, DataLoader, DataLoader]:\n",
    "        X, Y = self.read()\n",
    "        X, Y = self.preprocess(X, Y)\n",
    "        train_data, val_data, test_data = self.split(\n",
    "            X, Y, prop_train=prop_train, prop_val=prop_val\n",
    "        )\n",
    "        return self.batch(\n",
    "            train_data,\n",
    "            val_data,\n",
    "            test_data,\n",
    "            batch_size=batch_size,\n",
    "            shuffle_train=shuffle_train,\n",
    "            prefetch=prefetch,\n",
    "        )\n",
    "\n",
    "    @property\n",
    "    def needs_download(self):\n",
    "        return not os.path.isfile(self.datapath)\n",
    "\n",
    "    def download(self):\n",
    "        if self.needs_download:\n",
    "            logging.info(\"\\nDownloading {} data...\".format(self.name))\n",
    "\n",
    "            if not os.path.isdir(self.datadir):\n",
    "                os.mkdir(self.datadir)\n",
    "\n",
    "            filename = os.path.join(self.datadir, self.url.split(\"/\")[-1])\n",
    "            with urlopen(self.url) as response, open(filename, \"wb\") as out_file:\n",
    "                data = response.read()\n",
    "                out_file.write(data)\n",
    "\n",
    "            is_zipped = np.any([z in self.url for z in [\".gz\", \".zip\", \".tar\"]])\n",
    "            if is_zipped:\n",
    "                zip_ref = zipfile.ZipFile(filename, \"r\")\n",
    "                zip_ref.extractall(self.datadir)\n",
    "                zip_ref.close()\n",
    "\n",
    "            logging.info(\"Download completed.\".format(self.name))\n",
    "        else:\n",
    "            logging.info(\"{} dataset is already available.\".format(self.name))\n",
    "\n",
    "\n",
    "uci_base_url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/\"\n",
    "\n",
    "\n",
    "@add_regression\n",
    "class Boston(Dataset):\n",
    "    name = \"boston\"\n",
    "    url = uci_base_url + \"housing/housing.data\"\n",
    "\n",
    "    def __init__(self, directory, name=name, url=url):\n",
    "        super().__init__(name=name, url=url, directory=directory)\n",
    "\n",
    "    def read(self) -> Tuple[np.ndarray, np.ndarray]:\n",
    "        data = pd.read_fwf(self.datapath, header=None).values\n",
    "        return data[:, :-1], data[:, -1].reshape(-1, 1)\n",
    "\n",
    "\n",
    "@add_regression\n",
    "class Concrete(Dataset):\n",
    "    name = \"concrete\"\n",
    "    url = uci_base_url + \"concrete/compressive/Concrete_Data.xls\"\n",
    "\n",
    "    def __init__(self, directory, name=name, url=url):\n",
    "        super().__init__(name=name, url=url, directory=directory)\n",
    "\n",
    "    def read(self) -> Tuple[np.ndarray, np.ndarray]:\n",
    "        data = pd.read_excel(self.datapath).values\n",
    "        return data[:, :-1], data[:, -1].reshape(-1, 1)\n",
    "\n",
    "\n",
    "@add_regression\n",
    "class Energy(Dataset):\n",
    "    name = \"energy\"\n",
    "    url = uci_base_url + \"00242/ENB2012_data.xlsx\"\n",
    "\n",
    "    def __init__(self, directory, name=name, url=url):\n",
    "        super().__init__(name=name, url=url, directory=directory)\n",
    "\n",
    "    def read(self) -> Tuple[np.ndarray, np.ndarray]:\n",
    "        data = pd.read_excel(self.datapath).values[:, :-1]\n",
    "        return data[:, :-1], data[:, -1].reshape(-1, 1)\n",
    "\n",
    "\n",
    "@add_regression\n",
    "class Naval(Dataset):\n",
    "    name = \"naval\"\n",
    "    url = uci_base_url + \"00316/UCI%20CBM%20Dataset.zip\"\n",
    "\n",
    "    def __init__(self, directory, name=name, url=url):\n",
    "        super().__init__(name=name, url=url, directory=directory)\n",
    "\n",
    "    @property\n",
    "    def datapath(self):\n",
    "        return os.path.join(self.datadir, \"UCI CBM Dataset/data.txt\")\n",
    "\n",
    "    def read(self) -> Tuple[np.ndarray, np.ndarray]:\n",
    "        data = pd.read_fwf(self.datapath, header=None).values\n",
    "        X = data[:, :-2]\n",
    "        Y = data[:, -2].reshape(-1, 1)\n",
    "        X = np.delete(X, [8, 11], axis=1)\n",
    "        return X, Y\n",
    "\n",
    "\n",
    "@add_regression\n",
    "class Power(Dataset):\n",
    "    name = \"power\"\n",
    "    url = uci_base_url + \"00294/CCPP.zip\"\n",
    "\n",
    "    def __init__(self, directory, name=name, url=url):\n",
    "        super().__init__(name=name, url=url, directory=directory)\n",
    "\n",
    "    @property\n",
    "    def datapath(self):\n",
    "        return os.path.join(self.datadir, \"CCPP/Folds5x2_pp.xlsx\")\n",
    "\n",
    "    def read(self) -> Tuple[np.ndarray, np.ndarray]:\n",
    "        data = pd.read_excel(self.datapath).values\n",
    "        return data[:, :-1], data[:, -1].reshape(-1, 1)\n",
    "\n",
    "\n",
    "@add_regression\n",
    "class Protein(Dataset):\n",
    "    name = \"protein\"\n",
    "    url = uci_base_url + \"00265/CASP.csv\"\n",
    "\n",
    "    def __init__(self, directory, name=name, url=url):\n",
    "        super().__init__(name=name, url=url, directory=directory)\n",
    "\n",
    "    def read(self) -> Tuple[np.ndarray, np.ndarray]:\n",
    "        data = pd.read_csv(self.datapath).values\n",
    "        return data[:, 1:], data[:, 0].reshape(-1, 1)\n",
    "\n",
    "\n",
    "@add_regression\n",
    "class WineRed(Dataset):\n",
    "    name = \"winered\"\n",
    "    url = uci_base_url + \"wine-quality/winequality-red.csv\"\n",
    "\n",
    "    def __init__(self, directory, name=name, url=url):\n",
    "        super().__init__(name=name, url=url, directory=directory)\n",
    "\n",
    "    def read(self) -> Tuple[np.ndarray, np.ndarray]:\n",
    "        data = pd.read_csv(self.datapath, delimiter=\";\").values\n",
    "        return data[:, :-1], data[:, -1].reshape(-1, 1)\n",
    "\n",
    "\n",
    "@add_regression\n",
    "class WineWhite(Dataset):\n",
    "    name = \"winewhite\"\n",
    "    url = uci_base_url + \"wine-quality/winequality-white.csv\"\n",
    "\n",
    "    def __init__(self, directory, name=name, url=url):\n",
    "        super().__init__(name=name, url=url, directory=directory)\n",
    "\n",
    "    def read(self) -> Tuple[np.ndarray, np.ndarray]:\n",
    "        data = pd.read_csv(self.datapath, delimiter=\";\").values\n",
    "        return data[:, :-1], data[:, -1].reshape(-1, 1)\n",
    "\n",
    "\n",
    "@add_regression\n",
    "class Yacht(Dataset):\n",
    "    name = \"yacht\"\n",
    "    url = uci_base_url + \"/00243/yacht_hydrodynamics.data\"\n",
    "\n",
    "    def __init__(self, directory, name=name, url=url):\n",
    "        super().__init__(name=name, url=url, directory=directory)\n",
    "\n",
    "    def read(self) -> Tuple[np.ndarray, np.ndarray]:\n",
    "        data = pd.read_fwf(self.datapath, header=None).values[:-1, :]\n",
    "        return data[:, :-1], data[:, -1].reshape(-1, 1)\n",
    "\n",
    "\n",
    "regression_datasets = list(_ALL_REGRESSION_DATASETS.keys())\n",
    "regression_datasets.sort()\n",
    "\n",
    "\n",
    "def download_regression_dataset(name, directory, *args, **kwargs):\n",
    "    dataset = _ALL_REGRESSION_DATASETS[name](directory, *args, **kwargs)\n",
    "    dataset.download()\n",
    "\n",
    "\n",
    "def download_all_regression_datasets(directory, *args, **kwargs):\n",
    "    for name in list(_ALL_REGRESSION_DATASETS.keys()):\n",
    "        download_regression_dataset(name, directory, *args, **kwargs)\n",
    "\n",
    "\n",
    "def load_regression_dataset(\n",
    "    name, dir, *args, **kwargs\n",
    ") -> Tuple[DataLoader, DataLoader, DataLoader]:\n",
    "    dataset = _ALL_REGRESSION_DATASETS[name](dir)\n",
    "    return dataset.load(*args, **kwargs)\n",
    "\n",
    "\n",
    "download_all_regression_datasets(\".\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "778026f9",
   "metadata": {},
   "source": [
    "### Regression on each data set\n",
    "For each data set, we build a probabilistic regressor using MLP models for both mean and log-variance of the likelihood. We fit the posterior distribution with the default SWAG method, and calibrate the probabilistic model with a temperature scaling approach. Finally, compute 95% credible intervals and calibrate them with a quantile conformal method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ebdeb795",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch: 12 | loss: 2893.25708 | rmse: 0.52322:   4%|███████▎                                                                                                                                                                                               | 11/300 [00:00<00:14, 20.38it/s]\n",
      "Epoch: 300 | loss: 2512.47998 | rmse: 0.20301: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 300/300 [00:01<00:00, 219.28it/s]\n",
      "Epoch: 50 | loss: 34.62534:  16%|███████████████████████████████████▎                                                                                                                                                                                    | 49/300 [00:00<00:01, 154.37it/s]\n",
      "Epoch: 6 | loss: 3030.36548 | rmse: 0.54671:   2%|███▎                                                                                                                                                                                                     | 5/300 [00:00<00:55,  5.35it/s]\n",
      "Epoch: 300 | loss: 2215.96997 | rmse: 0.23145: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 300/300 [00:02<00:00, 114.58it/s]\n",
      "Epoch: 300 | loss: 131.73595: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 300/300 [00:00<00:00, 622.03it/s]\n",
      "Epoch: 8 | loss: 2576.00928 | rmse: 0.37866:   2%|████▋                                                                                                                                                                                                    | 7/300 [00:00<00:36,  8.12it/s]\n",
      "Epoch: 300 | loss: 1602.39172 | rmse: 0.09564: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 300/300 [00:02<00:00, 135.60it/s]\n",
      "Epoch: 136 | loss: -20.25236:  45%|███████████████████████████████████████████████████████████████████████████████████████████████▊                                                                                                                     | 135/300 [00:00<00:00, 303.62it/s]\n",
      "Epoch: 8 | loss: 11733.48926 | rmse: 0.58982:   2%|████▋                                                                                                                                                                                                   | 7/300 [00:01<00:48,  6.04it/s]\n",
      "Epoch: 300 | loss: -96.24042 | rmse: 0.23278: 100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 300/300 [00:14<00:00, 20.96it/s]\n",
      "Epoch: 4 | loss: 702.08295:   1%|██▏                                                                                                                                                                                                                       | 3/300 [00:00<00:46,  6.45it/s]\n",
      "Epoch: 8 | loss: 2259.3623 | rmse: 0.2454:   2%|████▋                                                                                                                                                                                                      | 7/300 [00:01<00:45,  6.48it/s]\n",
      "Epoch: 300 | loss: 603.2843 | rmse: 0.20549: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 300/300 [00:11<00:00, 25.94it/s]\n",
      "Epoch: 16 | loss: -41.26122:   5%|██████████▊                                                                                                                                                                                                             | 15/300 [00:00<00:09, 31.38it/s]\n",
      "Epoch: 9 | loss: 42336.62891 | rmse: 0.73108:   3%|█████▎                                                                                                                                                                                                  | 8/300 [00:01<00:58,  4.99it/s]\n",
      "Epoch: 300 | loss: 39881.39062 | rmse: 0.71115: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 300/300 [00:52<00:00,  5.75it/s]\n",
      "Epoch: 9 | loss: 3947.40283:   3%|█████▊                                                                                                                                                                                                                   | 8/300 [00:00<00:18, 15.56it/s]\n",
      "Epoch: 15 | loss: 3806.30762 | rmse: 0.71598:   5%|█████████▎                                                                                                                                                                                             | 14/300 [00:00<00:19, 14.74it/s]\n",
      "Epoch: 300 | loss: 3160.56079 | rmse: 0.70707: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 300/300 [00:03<00:00, 83.03it/s]\n",
      "Epoch: 300 | loss: 283.81815: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 300/300 [00:00<00:00, 602.45it/s]\n",
      "Epoch: 21 | loss: 7114.96729 | rmse: 0.78509:   7%|█████████████▎                                                                                                                                                                                         | 20/300 [00:01<00:14, 18.90it/s]\n",
      "Epoch: 300 | loss: 5706.80469 | rmse: 0.65381: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 300/300 [00:06<00:00, 46.09it/s]\n",
      "Epoch: 300 | loss: 661.33856: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 300/300 [00:00<00:00, 512.86it/s]\n",
      "Epoch: 17 | loss: 2312.48413 | rmse: 0.37405:   5%|██████████▌                                                                                                                                                                                            | 16/300 [00:00<00:09, 30.70it/s]\n",
      "Epoch: 300 | loss: 1803.91187 | rmse: 0.0788: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 300/300 [00:01<00:00, 225.23it/s]\n",
      "Epoch: 89 | loss: -23.77438:  29%|███████████████████████████████████████████████████████████████                                                                                                                                                        | 88/300 [00:00<00:00, 283.74it/s]\n"
     ]
    }
   ],
   "source": [
    "from fortuna.prob_model import ProbRegressor, FitConfig, FitMonitor, FitOptimizer, CalibConfig, CalibMonitor, CalibOptimizer\n",
    "from fortuna.model import MLP\n",
    "from fortuna.conformal import QuantileConformalRegressor\n",
    "from fortuna.metric.regression import rmse, picp\n",
    "import optax\n",
    "import tempfile\n",
    "\n",
    "all_status = dict()\n",
    "all_metrics = dict()\n",
    "\n",
    "for dataset_name in regression_datasets:\n",
    "    with tempfile.TemporaryDirectory() as data_dir:\n",
    "        # download and load data\n",
    "        download_regression_dataset(dataset_name, data_dir)\n",
    "        train_data_loader, val_data_loader, test_data_loader = load_regression_dataset(\n",
    "            dataset_name, data_dir, shuffle_train=True, batch_size=512\n",
    "        )\n",
    "\n",
    "        # find output dimension\n",
    "        for batch_inputs, batch_targets in train_data_loader:\n",
    "            output_dim = batch_targets.shape[-1]\n",
    "            break\n",
    "\n",
    "        # define probabilistic regressor\n",
    "        prob_model = ProbRegressor(\n",
    "            model=MLP(output_dim=output_dim),\n",
    "            likelihood_log_variance_model=MLP(output_dim=output_dim),\n",
    "        )\n",
    "\n",
    "        # train the probabilistic regression\n",
    "        all_status[dataset_name] = prob_model.train(\n",
    "            train_data_loader=train_data_loader,\n",
    "            val_data_loader=val_data_loader,\n",
    "            calib_data_loader=val_data_loader,\n",
    "            map_fit_config=FitConfig(\n",
    "                monitor=FitMonitor(metrics=(rmse,), early_stopping_patience=2),\n",
    "                optimizer=FitOptimizer(method=optax.adam(0.5 * 1e-1), n_epochs=300),\n",
    "            ),\n",
    "            fit_config=FitConfig(\n",
    "                monitor=FitMonitor(metrics=(rmse,)),\n",
    "                optimizer=FitOptimizer(method=optax.adam(0.2 * 1e-1), n_epochs=300),\n",
    "            ),\n",
    "            calib_config=CalibConfig(\n",
    "                monitor=CalibMonitor(early_stopping_patience=2),\n",
    "                optimizer=CalibOptimizer(n_epochs=300),\n",
    "            )\n",
    "        )\n",
    "\n",
    "        # compute predictive statistics\n",
    "        test_inputs_loader = test_data_loader.to_inputs_loader()\n",
    "        test_means = prob_model.predictive.mean(inputs_loader=test_inputs_loader)\n",
    "        test_cred_intervals = prob_model.predictive.credible_interval(\n",
    "            inputs_loader=test_inputs_loader\n",
    "        )\n",
    "\n",
    "        # calibrate the credibility intervals\n",
    "        val_inputs_loader = val_data_loader.to_inputs_loader()\n",
    "        val_cred_intervals = prob_model.predictive.credible_interval(\n",
    "            inputs_loader=val_inputs_loader\n",
    "        )\n",
    "        test_conformal_intervals = QuantileConformalRegressor().conformal_interval(\n",
    "            val_lower_bounds=val_cred_intervals[:, 0],\n",
    "            val_upper_bounds=val_cred_intervals[:, 1],\n",
    "            test_lower_bounds=test_cred_intervals[:, 0],\n",
    "            test_upper_bounds=test_cred_intervals[:, 1],\n",
    "            val_targets=val_data_loader.to_array_targets(),\n",
    "            error=0.05,\n",
    "        )\n",
    "\n",
    "        # compute metrics\n",
    "        all_metrics[dataset_name] = dict()\n",
    "        all_metrics[dataset_name][\"picp\"] = picp(\n",
    "            lower_bounds=test_conformal_intervals[:, 0],\n",
    "            upper_bounds=test_conformal_intervals[:, 1],\n",
    "            targets=test_data_loader.to_array_targets(),\n",
    "        )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "098ff0b4",
   "metadata": {},
   "source": [
    "SWAG invokes a Maximum-A-Posteriori (MAP) estimation algorithm and starts from there to approximate the posterior distribution. The following cell shows the loss decay during MAP for each data set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "bf4fe61b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2000x200 with 9 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig, axes = plt.subplots(1, len(all_status), figsize=(20, 2))\n",
    "for i, dataset_name in enumerate(all_status):\n",
    "    axes[i].set_title(dataset_name)\n",
    "    axes[0].set_ylabel(\"MAP loss decay\")\n",
    "    axes[i].plot(all_status[dataset_name][\"fit_status\"][\"map\"][\"loss\"])\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "851103e9",
   "metadata": {},
   "source": [
    "We finally plot the Prediction Interval Coverage Probability (PICP) for each data set. Since the credible intervals are computed with a 95% coverage, we should expect PICPs to be as close as possible to 0.95."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "441f8f4e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2000x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20, 3))\n",
    "plt.grid()\n",
    "plt.axhline(0.95, color=\"red\", alpha=0.5, linestyle=\"--\")\n",
    "plt.bar(\n",
    "    regression_datasets,\n",
    "    [all_metrics[dataset_name][\"picp\"] for dataset_name in all_metrics],\n",
    "    width=0.1,\n",
    ")\n",
    "plt.ylabel(\"PICP\", fontsize=12)\n",
    "plt.yticks(list(plt.yticks()[0]) + [0.95])\n",
    "plt.ylim([0, 1.1])\n",
    "for dataset_name in regression_datasets:\n",
    "    _picp = all_metrics[dataset_name][\"picp\"]\n",
    "    plt.annotate(str(round(float(_picp), 2)), (dataset_name, _picp + 0.01), fontsize=12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d76b4ed",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
